home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Archives / GNU / oleo_src.lha / src / list.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-18  |  3.6 KB  |  173 lines
  1. /*    Copyright (C) 1990 Free Software Foundation, Inc.
  2.  
  3. This file is part of Oleo, the GNU Spreadsheet.
  4.  
  5. Oleo is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 1, or (at your option)
  8. any later version.
  9.  
  10. Oleo is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with Oleo; see the file COPYING.  If not, write to
  17. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18.  
  19. #include "funcdef.h"
  20.  
  21. #include <stdio.h>
  22. #include <ctype.h>
  23. #include "sysdef.h"
  24.  
  25. #include "global.h"
  26. #include "cell.h"
  27.  
  28. extern struct rng all_rng;
  29.  
  30. static char sl_sep = '\t';
  31.  
  32. /* This file reads/writes files containing values in separated lists,
  33.    sl_sep is the separating character.  This isn't really a save-file
  34.    format, but it is useful for reading and writing tables written by other
  35.    programs.
  36.  
  37.    Note that this format loses *most* of the information about the cells,
  38.    including formuale, formats, column widths, etc
  39.  */
  40. void
  41. list_read_file FUN2(FILE *,fp, int,ismerge)
  42. {
  43.     char cbuf[1024];
  44.     CELLREF row,col;
  45.     char *bptr;
  46.     char *eptr;
  47.     char *ptr;
  48.     char tchar;
  49.     int endit;
  50.     unsigned lineno;
  51.     int string;
  52.     extern CELLREF curow,cucol;
  53.     extern void clear_spreadsheet EXT0();
  54.  
  55.     lineno=0;
  56.     if(!ismerge)
  57.         clear_spreadsheet();
  58.     row=curow;
  59.     col=cucol;
  60.  
  61.     while(fgets(&cbuf[1],sizeof(cbuf)-3,fp)) {
  62.         lineno++;
  63.         if(lineno%50==0)
  64.             info_msg("Line %d",lineno);
  65.         endit=0;
  66.         for(bptr= &cbuf[1];;bptr=eptr+1) {
  67.             eptr=index(bptr,sl_sep);
  68.             if(!eptr) {
  69.                 eptr=index(bptr,'\n');
  70.                 endit++;
  71.             }
  72.             string=0;
  73.             for(ptr=bptr;ptr!=eptr;ptr++)
  74.                 if(!isdigit(*ptr) && *ptr!='.' && *ptr!='e' && *ptr!='E') {
  75.                     string++;
  76.                     break;
  77.                 }
  78.             if(string) {
  79.                 bptr[-1]='"';
  80.                 eptr[0]='"';
  81.                 tchar=eptr[1];
  82.                 eptr[1]='\0';
  83.                 new_value(row,col,&bptr[-1]);
  84.                 eptr[1]=tchar;
  85.             } else {
  86.                 eptr[0]='\0';
  87.                 new_value(row,col,bptr);
  88.             }
  89.             if(endit)
  90.                 break;
  91.             col++;
  92.         }
  93.         row++;
  94.         col=cucol;
  95.     }
  96. }
  97.  
  98. void
  99. list_write_file FUN2(FILE *,fp, struct rng *,rng)
  100. {
  101.     CELLREF row,col;
  102.     int repressed;
  103.     CELL *cp;
  104.     extern char *bname[];
  105.     extern char *flt_to_str EXT1(double);
  106.  
  107.     if(!rng)
  108.         rng= &all_rng;
  109.     for(row=rng->lr;;row++) {
  110.         repressed=0;
  111.         for(col=rng->lc;;col++) {
  112.             if((cp=find_cell(row,col)) && GET_TYP(cp)) {
  113.                 while(repressed>0) {
  114.                     putc(sl_sep,fp);
  115.                     --repressed;
  116.                 }
  117.                 repressed=1;
  118.                 switch(GET_TYP(cp)) {
  119.                 case TYP_FLT:
  120.                     fputs(flt_to_str(cp->cell_flt),fp);
  121.                     break;
  122.                 case TYP_INT:
  123.                     fprintf(fp,"%ld",cp->cell_flt);
  124.                     break;
  125.                 case TYP_STR:
  126.                     fputs(cp->cell_str,fp);
  127.                     break;
  128.                 case TYP_BOL:
  129.                     fputs(bname[cp->cell_bol],fp);
  130.                     break;
  131.                 case TYP_ERR:
  132.                     fputs(ename[cp->cell_err],fp);
  133.                     break;
  134. #ifdef TEST
  135.                 default:
  136.                     panic("Unknown type %d in write_sl_file()",GET_TYP(cp));
  137.                     break;
  138. #endif
  139.                 }
  140.             } else
  141.                 repressed++;
  142.             if(col==rng->hc)
  143.                 break;
  144.         }
  145.         putc('\n',fp);
  146.         if(row==rng->hr)
  147.             break;
  148.     }
  149. }
  150.  
  151. int
  152. list_set_options FUN2(int,set_opt, char *,option)
  153. {
  154.     extern int strincmp();
  155.     extern int string_to_char();
  156.  
  157.     if(set_opt && !strincmp(option,"list ",5)) {
  158.         option+=5;
  159.         sl_sep=string_to_char(&option);
  160.         return 0;
  161.     }
  162.     return -1;
  163. }
  164.  
  165. void
  166. list_show_options FUN0()
  167. {
  168.     extern char *char_to_string();
  169.  
  170.     text_line("File format: list    (character separated list of cell values)");
  171.     text_line("Save file element separator: %s",char_to_string(sl_sep));
  172. }
  173.